home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / controls / scrollClasses / ScrollBar.as next >
Text File  |  2014-03-27  |  24KB  |  643 lines
  1. package mx.controls.scrollClasses
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.MouseEvent;
  5.    import flash.events.TimerEvent;
  6.    import flash.geom.Point;
  7.    import flash.ui.Keyboard;
  8.    import flash.utils.Timer;
  9.    import mx.controls.Button;
  10.    import mx.core.FlexVersion;
  11.    import mx.core.UIComponent;
  12.    import mx.core.mx_internal;
  13.    import mx.events.FlexEvent;
  14.    import mx.events.ScrollEvent;
  15.    import mx.events.ScrollEventDetail;
  16.    import mx.styles.ISimpleStyleClient;
  17.    import mx.styles.StyleProxy;
  18.    
  19.    use namespace mx_internal;
  20.    
  21.    public class ScrollBar extends UIComponent
  22.    {
  23.       
  24.       mx_internal static const VERSION:String = "3.0.0.0";
  25.       
  26.       public static const THICKNESS:Number = 16;
  27.        
  28.       
  29.       private var _direction:String = "vertical";
  30.       
  31.       private var _pageScrollSize:Number = 0;
  32.       
  33.       mx_internal var scrollTrack:Button;
  34.       
  35.       mx_internal var downArrow:Button;
  36.       
  37.       mx_internal var scrollThumb:ScrollThumb;
  38.       
  39.       private var trackScrollRepeatDirection:int;
  40.       
  41.       private var _minScrollPosition:Number = 0;
  42.       
  43.       private var trackPosition:Number;
  44.       
  45.       private var _pageSize:Number = 0;
  46.       
  47.       mx_internal var _minHeight:Number = 32;
  48.       
  49.       private var _maxScrollPosition:Number = 0;
  50.       
  51.       private var trackScrollTimer:Timer;
  52.       
  53.       mx_internal var upArrow:Button;
  54.       
  55.       private var _lineScrollSize:Number = 1;
  56.       
  57.       private var _scrollPosition:Number = 0;
  58.       
  59.       private var trackScrolling:Boolean = false;
  60.       
  61.       mx_internal var isScrolling:Boolean;
  62.       
  63.       mx_internal var oldPosition:Number;
  64.       
  65.       mx_internal var _minWidth:Number = 16;
  66.       
  67.       public function ScrollBar()
  68.       {
  69.          super();
  70.       }
  71.       
  72.       override public function set enabled(param1:Boolean) : void
  73.       {
  74.          super.enabled = param1;
  75.          invalidateDisplayList();
  76.       }
  77.       
  78.       public function set lineScrollSize(param1:Number) : void
  79.       {
  80.          _lineScrollSize = param1;
  81.       }
  82.       
  83.       public function get minScrollPosition() : Number
  84.       {
  85.          return _minScrollPosition;
  86.       }
  87.       
  88.       mx_internal function dispatchScrollEvent(param1:Number, param2:String) : void
  89.       {
  90.          var _loc3_:ScrollEvent = new ScrollEvent(ScrollEvent.SCROLL);
  91.          _loc3_.detail = param2;
  92.          _loc3_.position = scrollPosition;
  93.          _loc3_.delta = scrollPosition - param1;
  94.          _loc3_.direction = direction;
  95.          dispatchEvent(_loc3_);
  96.       }
  97.       
  98.       private function downArrow_buttonDownHandler(param1:FlexEvent) : void
  99.       {
  100.          if(isNaN(mx_internal::oldPosition))
  101.          {
  102.             oldPosition = scrollPosition;
  103.          }
  104.          lineScroll(1);
  105.       }
  106.       
  107.       private function scrollTrack_mouseDownHandler(param1:MouseEvent) : void
  108.       {
  109.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  110.          {
  111.             return;
  112.          }
  113.          trackScrolling = true;
  114.          systemManager.addEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  115.          systemManager.addEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  116.          systemManager.stage.addEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  117.          systemManager.stage.addEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  118.          var _loc2_:Point = new Point(param1.localX,param1.localY);
  119.          _loc2_ = param1.target.localToGlobal(_loc2_);
  120.          _loc2_ = globalToLocal(_loc2_);
  121.          trackPosition = _loc2_.y;
  122.          if(isNaN(mx_internal::oldPosition))
  123.          {
  124.             oldPosition = scrollPosition;
  125.          }
  126.          trackScrollRepeatDirection = mx_internal::scrollThumb.y + mx_internal::scrollThumb.height < _loc2_.y ? 1 : (mx_internal::scrollThumb.y > _loc2_.y ? -1 : 0);
  127.          pageScroll(trackScrollRepeatDirection);
  128.          if(!trackScrollTimer)
  129.          {
  130.             trackScrollTimer = new Timer(getStyle("repeatDelay"),1);
  131.             trackScrollTimer.addEventListener(TimerEvent.TIMER,trackScrollTimerHandler);
  132.          }
  133.          trackScrollTimer.start();
  134.       }
  135.       
  136.       public function set minScrollPosition(param1:Number) : void
  137.       {
  138.          _minScrollPosition = param1;
  139.       }
  140.       
  141.       public function get scrollPosition() : Number
  142.       {
  143.          return _scrollPosition;
  144.       }
  145.       
  146.       mx_internal function get linePlusDetail() : String
  147.       {
  148.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_DOWN : ScrollEventDetail.LINE_RIGHT;
  149.       }
  150.       
  151.       public function get maxScrollPosition() : Number
  152.       {
  153.          return _maxScrollPosition;
  154.       }
  155.       
  156.       protected function get thumbStyleFilters() : Object
  157.       {
  158.          return null;
  159.       }
  160.       
  161.       override public function set doubleClickEnabled(param1:Boolean) : void
  162.       {
  163.       }
  164.       
  165.       public function get lineScrollSize() : Number
  166.       {
  167.          return _lineScrollSize;
  168.       }
  169.       
  170.       private function stage_scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  171.       {
  172.          if(param1.target != stage)
  173.          {
  174.             return;
  175.          }
  176.          scrollTrack_mouseMoveHandler(param1);
  177.       }
  178.       
  179.       mx_internal function get virtualHeight() : Number
  180.       {
  181.          return unscaledHeight;
  182.       }
  183.       
  184.       public function set scrollPosition(param1:Number) : void
  185.       {
  186.          var _loc2_:Number = NaN;
  187.          var _loc3_:Number = NaN;
  188.          var _loc4_:Number = NaN;
  189.          _scrollPosition = param1;
  190.          if(mx_internal::scrollThumb)
  191.          {
  192.             if(!cacheAsBitmap)
  193.             {
  194.                cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = true;
  195.             }
  196.             if(!mx_internal::isScrolling)
  197.             {
  198.                param1 = Math.min(param1,maxScrollPosition);
  199.                param1 = Math.max(param1,minScrollPosition);
  200.                _loc2_ = maxScrollPosition - minScrollPosition;
  201.                _loc3_ = _loc2_ == 0 || isNaN(_loc2_) ? Number(0) : Number((param1 - minScrollPosition) * (trackHeight - mx_internal::scrollThumb.height) / _loc2_ + trackY);
  202.                _loc4_ = (mx_internal::virtualWidth - mx_internal::scrollThumb.width) / 2 + getStyle("thumbOffset");
  203.                mx_internal::scrollThumb.move(Math.round(_loc4_),Math.round(_loc3_));
  204.             }
  205.          }
  206.       }
  207.       
  208.       protected function get downArrowStyleFilters() : Object
  209.       {
  210.          return null;
  211.       }
  212.       
  213.       public function get pageSize() : Number
  214.       {
  215.          return _pageSize;
  216.       }
  217.       
  218.       public function set pageScrollSize(param1:Number) : void
  219.       {
  220.          _pageScrollSize = param1;
  221.       }
  222.       
  223.       public function set maxScrollPosition(param1:Number) : void
  224.       {
  225.          _maxScrollPosition = param1;
  226.       }
  227.       
  228.       mx_internal function pageScroll(param1:int) : void
  229.       {
  230.          var _loc4_:Number = NaN;
  231.          var _loc5_:String = null;
  232.          var _loc2_:Number = _pageScrollSize != 0 ? Number(_pageScrollSize) : Number(pageSize);
  233.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  234.          if(_loc3_ > maxScrollPosition)
  235.          {
  236.             _loc3_ = maxScrollPosition;
  237.          }
  238.          else if(_loc3_ < minScrollPosition)
  239.          {
  240.             _loc3_ = minScrollPosition;
  241.          }
  242.          if(_loc3_ != scrollPosition)
  243.          {
  244.             _loc4_ = scrollPosition;
  245.             scrollPosition = _loc3_;
  246.             _loc5_ = param1 < 0 ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  247.             dispatchScrollEvent(_loc4_,_loc5_);
  248.          }
  249.       }
  250.       
  251.       override protected function createChildren() : void
  252.       {
  253.          super.createChildren();
  254.          if(!mx_internal::scrollTrack)
  255.          {
  256.             scrollTrack = new Button();
  257.             mx_internal::scrollTrack.focusEnabled = false;
  258.             mx_internal::scrollTrack.skinName = "trackSkin";
  259.             mx_internal::scrollTrack.upSkinName = "trackUpSkin";
  260.             mx_internal::scrollTrack.overSkinName = "trackOverSkin";
  261.             mx_internal::scrollTrack.downSkinName = "trackDownSkin";
  262.             mx_internal::scrollTrack.disabledSkinName = "trackDisabledSkin";
  263.             if(mx_internal::scrollTrack is ISimpleStyleClient)
  264.             {
  265.                ISimpleStyleClient(mx_internal::scrollTrack).styleName = this;
  266.             }
  267.             addChild(mx_internal::scrollTrack);
  268.             mx_internal::scrollTrack.validateProperties();
  269.          }
  270.          if(!mx_internal::upArrow)
  271.          {
  272.             upArrow = new Button();
  273.             mx_internal::upArrow.enabled = false;
  274.             mx_internal::upArrow.autoRepeat = true;
  275.             mx_internal::upArrow.focusEnabled = false;
  276.             mx_internal::upArrow.upSkinName = "upArrowUpSkin";
  277.             mx_internal::upArrow.overSkinName = "upArrowOverSkin";
  278.             mx_internal::upArrow.downSkinName = "upArrowDownSkin";
  279.             mx_internal::upArrow.disabledSkinName = "upArrowDisabledSkin";
  280.             mx_internal::upArrow.skinName = "upArrowSkin";
  281.             mx_internal::upArrow.upIconName = "";
  282.             mx_internal::upArrow.overIconName = "";
  283.             mx_internal::upArrow.downIconName = "";
  284.             mx_internal::upArrow.disabledIconName = "";
  285.             addChild(mx_internal::upArrow);
  286.             mx_internal::upArrow.styleName = new StyleProxy(this,upArrowStyleFilters);
  287.             mx_internal::upArrow.validateProperties();
  288.             mx_internal::upArrow.addEventListener(FlexEvent.BUTTON_DOWN,upArrow_buttonDownHandler);
  289.          }
  290.          if(!mx_internal::downArrow)
  291.          {
  292.             downArrow = new Button();
  293.             mx_internal::downArrow.enabled = false;
  294.             mx_internal::downArrow.autoRepeat = true;
  295.             mx_internal::downArrow.focusEnabled = false;
  296.             mx_internal::downArrow.upSkinName = "downArrowUpSkin";
  297.             mx_internal::downArrow.overSkinName = "downArrowOverSkin";
  298.             mx_internal::downArrow.downSkinName = "downArrowDownSkin";
  299.             mx_internal::downArrow.disabledSkinName = "downArrowDisabledSkin";
  300.             mx_internal::downArrow.skinName = "downArrowSkin";
  301.             mx_internal::downArrow.upIconName = "";
  302.             mx_internal::downArrow.overIconName = "";
  303.             mx_internal::downArrow.downIconName = "";
  304.             mx_internal::downArrow.disabledIconName = "";
  305.             addChild(mx_internal::downArrow);
  306.             mx_internal::downArrow.styleName = new StyleProxy(this,downArrowStyleFilters);
  307.             mx_internal::downArrow.validateProperties();
  308.             mx_internal::downArrow.addEventListener(FlexEvent.BUTTON_DOWN,downArrow_buttonDownHandler);
  309.          }
  310.       }
  311.       
  312.       private function scrollTrack_mouseOverHandler(param1:MouseEvent) : void
  313.       {
  314.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  315.          {
  316.             return;
  317.          }
  318.          if(trackScrolling)
  319.          {
  320.             trackScrollTimer.start();
  321.          }
  322.       }
  323.       
  324.       private function get minDetail() : String
  325.       {
  326.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_TOP : ScrollEventDetail.AT_LEFT;
  327.       }
  328.       
  329.       mx_internal function isScrollBarKey(param1:uint) : Boolean
  330.       {
  331.          var _loc2_:Number = NaN;
  332.          if(param1 == Keyboard.HOME)
  333.          {
  334.             if(scrollPosition != 0)
  335.             {
  336.                _loc2_ = scrollPosition;
  337.                scrollPosition = 0;
  338.                dispatchScrollEvent(_loc2_,minDetail);
  339.             }
  340.             return true;
  341.          }
  342.          if(param1 == Keyboard.END)
  343.          {
  344.             if(scrollPosition < maxScrollPosition)
  345.             {
  346.                _loc2_ = scrollPosition;
  347.                scrollPosition = maxScrollPosition;
  348.                dispatchScrollEvent(_loc2_,maxDetail);
  349.             }
  350.             return true;
  351.          }
  352.          return false;
  353.       }
  354.       
  355.       mx_internal function get lineMinusDetail() : String
  356.       {
  357.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_LEFT;
  358.       }
  359.       
  360.       mx_internal function get pageMinusDetail() : String
  361.       {
  362.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_UP : ScrollEventDetail.PAGE_LEFT;
  363.       }
  364.       
  365.       private function get maxDetail() : String
  366.       {
  367.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_BOTTOM : ScrollEventDetail.AT_RIGHT;
  368.       }
  369.       
  370.       private function scrollTrack_mouseLeaveHandler(param1:Event) : void
  371.       {
  372.          trackScrolling = false;
  373.          systemManager.removeEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  374.          systemManager.removeEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  375.          systemManager.stage.removeEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  376.          systemManager.stage.removeEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  377.          if(trackScrollTimer)
  378.          {
  379.             trackScrollTimer.reset();
  380.          }
  381.          if(param1.target != mx_internal::scrollTrack)
  382.          {
  383.             return;
  384.          }
  385.          var _loc2_:String = mx_internal::oldPosition > scrollPosition ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  386.          dispatchScrollEvent(mx_internal::oldPosition,_loc2_);
  387.          oldPosition = NaN;
  388.       }
  389.       
  390.       protected function get upArrowStyleFilters() : Object
  391.       {
  392.          return null;
  393.       }
  394.       
  395.       private function get trackHeight() : Number
  396.       {
  397.          return mx_internal::virtualHeight - (mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight());
  398.       }
  399.       
  400.       public function get pageScrollSize() : Number
  401.       {
  402.          return _pageScrollSize;
  403.       }
  404.       
  405.       override protected function measure() : void
  406.       {
  407.          super.measure();
  408.          mx_internal::upArrow.validateSize();
  409.          mx_internal::downArrow.validateSize();
  410.          mx_internal::scrollTrack.validateSize();
  411.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  412.          {
  413.             _minWidth = !!mx_internal::scrollThumb ? Number(mx_internal::scrollThumb.getExplicitOrMeasuredWidth()) : Number(0);
  414.             _minWidth = Math.max(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::_minWidth);
  415.          }
  416.          else
  417.          {
  418.             _minWidth = mx_internal::upArrow.getExplicitOrMeasuredWidth();
  419.          }
  420.          _minHeight = mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight();
  421.       }
  422.       
  423.       mx_internal function lineScroll(param1:int) : void
  424.       {
  425.          var _loc4_:Number = NaN;
  426.          var _loc5_:String = null;
  427.          var _loc2_:Number = _lineScrollSize;
  428.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  429.          if(_loc3_ > maxScrollPosition)
  430.          {
  431.             _loc3_ = maxScrollPosition;
  432.          }
  433.          else if(_loc3_ < minScrollPosition)
  434.          {
  435.             _loc3_ = minScrollPosition;
  436.          }
  437.          if(_loc3_ != scrollPosition)
  438.          {
  439.             _loc4_ = scrollPosition;
  440.             scrollPosition = _loc3_;
  441.             _loc5_ = param1 < 0 ? mx_internal::lineMinusDetail : mx_internal::linePlusDetail;
  442.             dispatchScrollEvent(_loc4_,_loc5_);
  443.          }
  444.       }
  445.       
  446.       public function setScrollProperties(param1:Number, param2:Number, param3:Number, param4:Number = 0) : void
  447.       {
  448.          var _loc5_:Number = NaN;
  449.          this.pageSize = param1;
  450.          _pageScrollSize = param4 > 0 ? Number(param4) : Number(param1);
  451.          this.minScrollPosition = Math.max(param2,0);
  452.          this.maxScrollPosition = Math.max(param3,0);
  453.          _scrollPosition = Math.max(this.minScrollPosition,_scrollPosition);
  454.          _scrollPosition = Math.min(this.maxScrollPosition,_scrollPosition);
  455.          if(this.maxScrollPosition - this.minScrollPosition > 0 && enabled)
  456.          {
  457.             mx_internal::upArrow.enabled = true;
  458.             mx_internal::downArrow.enabled = true;
  459.             mx_internal::scrollTrack.enabled = true;
  460.             addEventListener(MouseEvent.MOUSE_DOWN,scrollTrack_mouseDownHandler);
  461.             addEventListener(MouseEvent.MOUSE_OVER,scrollTrack_mouseOverHandler);
  462.             addEventListener(MouseEvent.MOUSE_OUT,scrollTrack_mouseOutHandler);
  463.             if(!mx_internal::scrollThumb)
  464.             {
  465.                scrollThumb = new ScrollThumb();
  466.                mx_internal::scrollThumb.focusEnabled = false;
  467.                addChildAt(mx_internal::scrollThumb,getChildIndex(mx_internal::downArrow));
  468.                mx_internal::scrollThumb.styleName = new StyleProxy(this,thumbStyleFilters);
  469.                mx_internal::scrollThumb.upSkinName = "thumbUpSkin";
  470.                mx_internal::scrollThumb.overSkinName = "thumbOverSkin";
  471.                mx_internal::scrollThumb.downSkinName = "thumbDownSkin";
  472.                mx_internal::scrollThumb.iconName = "thumbIcon";
  473.                mx_internal::scrollThumb.skinName = "thumbSkin";
  474.             }
  475.             if((_loc5_ = trackHeight < 0 ? Number(0) : Number(Math.round(param1 / (this.maxScrollPosition - this.minScrollPosition + param1) * trackHeight))) < mx_internal::scrollThumb.minHeight)
  476.             {
  477.                if(trackHeight < mx_internal::scrollThumb.minHeight)
  478.                {
  479.                   mx_internal::scrollThumb.visible = false;
  480.                }
  481.                else
  482.                {
  483.                   _loc5_ = mx_internal::scrollThumb.minHeight;
  484.                   mx_internal::scrollThumb.visible = true;
  485.                   mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,mx_internal::scrollThumb.minHeight);
  486.                }
  487.             }
  488.             else
  489.             {
  490.                mx_internal::scrollThumb.visible = true;
  491.                mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,_loc5_);
  492.             }
  493.             mx_internal::scrollThumb.setRange(mx_internal::upArrow.getExplicitOrMeasuredHeight() + 0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight() - mx_internal::scrollThumb.height,this.minScrollPosition,this.maxScrollPosition);
  494.             scrollPosition = Math.max(Math.min(scrollPosition,this.maxScrollPosition),this.minScrollPosition);
  495.          }
  496.          else
  497.          {
  498.             mx_internal::upArrow.enabled = false;
  499.             mx_internal::downArrow.enabled = false;
  500.             mx_internal::scrollTrack.enabled = false;
  501.             if(mx_internal::scrollThumb)
  502.             {
  503.                mx_internal::scrollThumb.visible = false;
  504.             }
  505.          }
  506.       }
  507.       
  508.       private function trackScrollTimerHandler(param1:Event) : void
  509.       {
  510.          if(trackScrollRepeatDirection == 1)
  511.          {
  512.             if(mx_internal::scrollThumb.y + mx_internal::scrollThumb.height > trackPosition)
  513.             {
  514.                return;
  515.             }
  516.          }
  517.          if(trackScrollRepeatDirection == -1)
  518.          {
  519.             if(mx_internal::scrollThumb.y < trackPosition)
  520.             {
  521.                return;
  522.             }
  523.          }
  524.          pageScroll(trackScrollRepeatDirection);
  525.          if(trackScrollTimer && trackScrollTimer.repeatCount == 1)
  526.          {
  527.             trackScrollTimer.delay = getStyle("repeatInterval");
  528.             trackScrollTimer.repeatCount = 0;
  529.          }
  530.       }
  531.       
  532.       private function upArrow_buttonDownHandler(param1:FlexEvent) : void
  533.       {
  534.          if(isNaN(mx_internal::oldPosition))
  535.          {
  536.             oldPosition = scrollPosition;
  537.          }
  538.          lineScroll(-1);
  539.       }
  540.       
  541.       public function set pageSize(param1:Number) : void
  542.       {
  543.          _pageSize = param1;
  544.       }
  545.       
  546.       private function get trackY() : Number
  547.       {
  548.          return mx_internal::upArrow.getExplicitOrMeasuredHeight();
  549.       }
  550.       
  551.       private function scrollTrack_mouseOutHandler(param1:MouseEvent) : void
  552.       {
  553.          if(trackScrolling)
  554.          {
  555.             trackScrollTimer.stop();
  556.          }
  557.       }
  558.       
  559.       private function scrollTrack_mouseUpHandler(param1:MouseEvent) : void
  560.       {
  561.          scrollTrack_mouseLeaveHandler(param1);
  562.       }
  563.       
  564.       private function scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  565.       {
  566.          var _loc2_:Point = null;
  567.          if(trackScrolling)
  568.          {
  569.             _loc2_ = new Point(param1.stageX,param1.stageY);
  570.             _loc2_ = globalToLocal(_loc2_);
  571.             trackPosition = _loc2_.y;
  572.          }
  573.       }
  574.       
  575.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  576.       {
  577.          if(mx_internal::$height == 1)
  578.          {
  579.             return;
  580.          }
  581.          if(!mx_internal::upArrow)
  582.          {
  583.             return;
  584.          }
  585.          super.updateDisplayList(param1,param2);
  586.          if(cacheAsBitmap)
  587.          {
  588.             cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = false;
  589.          }
  590.          mx_internal::upArrow.setActualSize(mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredHeight());
  591.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  592.          {
  593.             mx_internal::upArrow.move((mx_internal::virtualWidth - mx_internal::upArrow.width) / 2,0);
  594.          }
  595.          else
  596.          {
  597.             mx_internal::upArrow.move(0,0);
  598.          }
  599.          mx_internal::scrollTrack.setActualSize(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::virtualHeight);
  600.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  601.          {
  602.             mx_internal::scrollTrack.x = (mx_internal::virtualWidth - mx_internal::scrollTrack.width) / 2;
  603.          }
  604.          mx_internal::scrollTrack.y = 0;
  605.          mx_internal::downArrow.setActualSize(mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredHeight());
  606.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  607.          {
  608.             mx_internal::downArrow.move((mx_internal::virtualWidth - mx_internal::downArrow.width) / 2,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  609.          }
  610.          else
  611.          {
  612.             mx_internal::downArrow.move(0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  613.          }
  614.          setScrollProperties(pageSize,minScrollPosition,maxScrollPosition,_pageScrollSize);
  615.          scrollPosition = _scrollPosition;
  616.       }
  617.       
  618.       mx_internal function get pagePlusDetail() : String
  619.       {
  620.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_DOWN : ScrollEventDetail.PAGE_RIGHT;
  621.       }
  622.       
  623.       mx_internal function get virtualWidth() : Number
  624.       {
  625.          return unscaledWidth;
  626.       }
  627.       
  628.       public function set direction(param1:String) : void
  629.       {
  630.          _direction = param1;
  631.          invalidateSize();
  632.          invalidateDisplayList();
  633.          dispatchEvent(new Event("directionChanged"));
  634.       }
  635.       
  636.       [Bindable("directionChanged")]
  637.       public function get direction() : String
  638.       {
  639.          return _direction;
  640.       }
  641.    }
  642. }
  643.